home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / u_man / cat1 / pmake.z / pmake
Encoding:
Text File  |  2002-10-03  |  83.4 KB  |  1,558 lines

  1.  
  2.  
  3.  
  4. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      pmake, smake - create programs in parallel
  10.  
  11. SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
  12.      ppppmmmmaaaakkkkeeee [----dddd _w_h_a_t] [----eeee] [----ffff _m_a_k_e_f_i_l_e] [----hhhh] [----iiii] [----kkkk] [----llll] [----nnnn] [----pppp #] [----qqqq]
  13.           [----rrrr] [----ssss] [----tttt] [----vvvv] [----BBBB] [----CCCC] [----DDDD _v_a_r_i_a_b_l_e] [----IIII _d_i_r_e_c_t_o_r_y]
  14.           [----JJJJ #] [----MMMM] [----PPPP] [----VVVV] [----WWWW] [_V_A_R_1====_v_a_l_u_e_1] [_V_A_R_2====_v_a_l_u_e_2............] [_t_a_r_g_1]
  15.           [_t_a_r_g_2 ...]
  16.  
  17. AAAARRRRGGGGUUUUMMMMEEEENNNNTTTTSSSS
  18.      -d   _w_h_a_t         Specify what modules should print debugging
  19.                        information.  _w_h_a_t is a string of letters from the
  20.                        following set: a, c, d, j, m, s, t, v. Use A or * to
  21.                        print all information.
  22.  
  23.      -e                Give environment variables precedence over those in the
  24.                        makefile(s).
  25.  
  26.      -f   _m_a_k_e_f_i_l_e     Specify a different makefile to read than the standard
  27.                        ``Makefile'' or ``makefile''.  If _m_a_k_e_f_i_l_e is "-",
  28.                        standard input is read.
  29.  
  30.      -h                Prints out help information and default values.
  31.  
  32.      -i                ``Ignore errors'' - ignore non-zero exit statuses of
  33.                        commands.
  34.  
  35.      -k                ``Keep-going'' - if an error is encountered, keep
  36.                        working on those parts of the input graph that are not
  37.                        affected by the error.
  38.  
  39.      -l                Create a lock file (called ``LOCK.make'') to prevent
  40.                        other people from executing ppppmmmmaaaakkkkeeee in the same
  41.                        directory.  Useful when simultaneous makes in the same
  42.                        place can be disastrous for the final product (too many
  43.                        cooks and all that).  Note that this locking will not
  44.                        prevent _y_o_u from invoking ppppmmmmaaaakkkkeeee twice in the same place
  45.                        - if you own the lock file, ppppmmmmaaaakkkkeeee will warn you about
  46.                        it but continue to execute.
  47.  
  48.      -n                ``No execute'' - do not execute commands.  Just print
  49.                        the ones that would be executed.
  50.  
  51.      -p   #            Tell ppppmmmmaaaakkkkeeee if and when to print the input graph.  The
  52.                        number is the bitwise OR of the numbers 1 and 2.  1
  53.                        means print the graph before making anything and 2
  54.                        means print the graph after making everything. 3 means
  55.                        do both.
  56.  
  57.      -q                ``Query'' - do not execute any commands.  Just exit 0
  58.                        if the given target(s) is (are) up to date and exit
  59.                        non-zero otherwise.
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  71.  
  72.  
  73.  
  74.      -r                ``Remove built-in rules'' - do not parse the built-in
  75.                        rules given in the system makefile.
  76.  
  77.      -s                ``Silence'' - do not echo commands as they are
  78.                        executed.
  79.  
  80.      -t                ``Touch targets'' - rather than executing the commands
  81.                        to create a target, just change its modification time
  82.                        so it appears up-to-date.  This is dangerous.
  83.  
  84.      -v                ``System V'' - invokes compatibility functions suitable
  85.                        for acting like the System V (IRIX) version of mmmmaaaakkkkeeee(1).
  86.                        This implies ----BBBB, and ----VVVV.  Automatically set when ppppmmmmaaaakkkkeeee
  87.                        is invoked as _ssss_mmmm_aaaa_kkkk_eeee.
  88.  
  89.      -B                ``Backwards-compatible'' - performs as much like
  90.                        mmmmaaaakkkkeeee(1) as possible (including executing a single shell
  91.                        per command and expanding variables as mmmmaaaakkkkeeee did) while
  92.                        still performing in parallel.
  93.  
  94.      -C                ``Non-compatible'' - turns off all compatibility
  95.                        specified up to the point at which ----CCCC is encountered.
  96.  
  97.      -D   _v_a_r_i_a_b_l_e     Defines the given variable to be 1111 in the global
  98.                        context.
  99.  
  100.      -I   _d_i_r_e_c_t_o_r_y    Specify another directory in which to look for
  101.                        #include'd makefiles.  This flag may be repeated as
  102.                        many times as necessary.
  103.  
  104.      -J   #            Specify the maximum number of jobs to run at once.
  105.  
  106.      -M                Be as much like mmmmaaaakkkkeeee(1) as possible. No parallel
  107.                        execution. Old-style variable expansion. One shell per
  108.                        command, etc.
  109.  
  110.      -P                ``Don't use Pipes'' - see the section on OOOOUUUUTTTTPPPPUUUUTTTT.
  111.  
  112.      -V                ``Do old-style variable expansion'' - expands an
  113.                        unknown variable to the empty string.
  114.  
  115.      -W                Don't print warning messages.
  116.  
  117.      VAR=value         Set the value of the variable VVVVAAAARRRR to the given value.
  118.                        This supersedes any value assigned to the variable in
  119.                        the makefile.  See VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS.
  120.  
  121.      ssssmmmmaaaakkkkeeee is equivalent to ppppmmmmaaaakkkkeeee ----vvvv.
  122.  
  123.      The flags -x, -X and -L are recognized but ignored by this implementation
  124.      of ppppmmmmaaaakkkkeeee.
  125.  
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  137.  
  138.  
  139.  
  140. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  141.      ppppmmmmaaaakkkkeeee is a program designed to make the maintenance of other programs
  142.      much easier. Its input is a ``makefile'' that specifies which files
  143.      depend on which other files and what to do about files that are ``out-
  144.      of-date.''  ppppmmmmaaaakkkkeeee's most important feature is its ability to run several
  145.      different jobs at once, making the creation of systems considerably
  146.      faster. It also has a great deal more functionality than mmmmaaaakkkkeeee(1).
  147.  
  148.      ppppmmmmaaaakkkkeeee is generally compatible with mmmmaaaakkkkeeee(1).  The main differences are:
  149.  
  150.      1) The ppppmmmmaaaakkkkeeee variable substitution, as described below, is very different
  151.         and will cause problems unless the makefile is converted or the ----VVVV
  152.         flag is given or when ppppmmmmaaaakkkkeeee is invoked as _ssss_mmmm_aaaa_kkkk_eeee.
  153.  
  154.      2) Because ppppmmmmaaaakkkkeeee creates targets in parallel, certain sequences which
  155.         depend on the sources of a target being created sequentially will
  156.         fail.  For example:
  157.            prod : $(PROGRAM) clean
  158.         This is liable to cause some of the object files to be removed after
  159.         having been created during the current invocation (or, at the very
  160.         least, the object files will not be removed when the program has been
  161.         made), leading to errors in the final linking stage. This problem
  162.         cannot even be avoided by limiting the maximum concurrency to one,
  163.         since the traversal of the dependency graph is done in a breadth-
  164.         first, rather than a depth-first way. For mmmmaaaakkkkeeee(1) behavior, rewrite
  165.         the makefile, or give ppppmmmmaaaakkkkeeee the ----MMMM flag.
  166.  
  167.      3) ppppmmmmaaaakkkkeeee forks only one shell to execute the commands to recreate a
  168.         target.  This means that changes of directory, environment, etc.,
  169.         remain in effect throughout the creation process. It also allows for a
  170.         more natural entry of shell loop constructs without the need for
  171.         backslashes and semicolons required by the one-shell-per-command
  172.         paradigm used by mmmmaaaakkkkeeee(1).  It is possible to have ppppmmmmaaaakkkkeeee execute each
  173.         command in a single shell by giving it the ----BBBB flag.
  174.  
  175.      4) ppppmmmmaaaakkkkeeee strips the leading directory from the files in a target's local
  176.         variables, unlike mmmmaaaakkkkeeee(1).  For example, ppppmmmmaaaakkkkeeee looks in the current
  177.         directory for file.c when making gen/file.o:
  178.            default:   gen/file.o
  179.            .c.o:
  180.                 cc -c  -o  $@  $<
  181.         To have ppppmmmmaaaakkkkeeee look in the gen directory for file.c, add a ``.PATH:
  182.         gen'' target to the makefile. The ....PPPPAAAATTTTHHHH target, which is described
  183.         below, is ignored by mmmmaaaakkkkeeee(1).  Note that ppppmmmmaaaakkkkeeee in system V (IRIX)
  184.         compatibility mode will not strip leading directories.
  185.  
  186.      5) ppppmmmmaaaakkkkeeee can interpret a comment line that begins with ``# if'' as a
  187.         conditional statement. Duplicate the comment character before the line
  188.         to avoid a warning message.
  189.  
  190.  
  191.  
  192.  
  193.                                                                         PPPPaaaaggggeeee 3333
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  201.  
  202.  
  203.  
  204.      6) ppppmmmmaaaakkkkeeee doesn't have mmmmaaaakkkkeeee(1)'s tilde rules for SCCS files.
  205.  
  206.      7) ppppmmmmaaaakkkkeeee only understands the i,k,n,q,r,s,t, and u options in mmmmaaaakkkkeeee's
  207.         MAKEFLAGS environment variable. The other mmmmaaaakkkkeeee options are ignored due
  208.         to differences in semantics.
  209.  
  210.      8) ppppmmmmaaaakkkkeeee converts an escaped newline into a space.
  211.  
  212. MMMMAAAAKKKKEEEEFFFFIIIILLLLEEEESSSS
  213.      If you don't specify a makefile to read, ppppmmmmaaaakkkkeeee looks for MMMMaaaakkkkeeeeffffiiiilllleeee in the
  214.      current directory.  If that file does not exist, it looks for mmmmaaaakkkkeeeeffffiiiilllleeee.
  215.      (This search order is reversed for _ssss_mmmm_aaaa_kkkk_eeee or when using the ----MMMM flag.)
  216.  
  217.      There are four basic types of lines in a makefile:
  218.  
  219.      1) File dependency specifications
  220.  
  221.      2) Creation commands
  222.  
  223.      3) Variable assignments
  224.  
  225.      4) Comments, include statements and conditional directives
  226.  
  227.      Any line may be continued over multiple lines by ending it with a
  228.      backslash.  The backslash, following newline and any initial white-space
  229.      on the following line are compressed into a single space.
  230.  
  231. DDDDEEEEPPPPEEEENNNNDDDDEEEENNNNCCCCYYYY LLLLIIIINNNNEEEESSSS
  232.      On a dependency line, there are targets, sources and an operator.  The
  233.      targets ``depend'' on the sources and are usually created from them.  Any
  234.      number of targets and sources may be specified on a dependency line. All
  235.      the targets in the line are made to depend on all the sources.  If you
  236.      run out of room, use a backslash at the end of the line to continue onto
  237.      the next one.
  238.  
  239.      Any file may be a target and any file may be a source, but the
  240.      relationship between them is determined by the ``operator'' that
  241.      separates them. Three operators are defined:
  242.  
  243.           :    A target on the line is considered ``out-of-date'' if any of
  244.                its sources has been modified more recently than the target.
  245.                Sources for a target accumulate over lines when this operator
  246.                is used.
  247.  
  248.           !    Targets will always be recreated, but this will not happen
  249.                until all of its sources have been examined and recreated, if
  250.                necessary.  Sources accumulate over lines as for the colon.
  251.  
  252.           ::   Much like the colon, but acts like the ! operator if no sources
  253.                are specified. In addition sources do not accumulate over
  254.                lines. Rather, the commands associated with the line (see
  255.                below) are executed only if the target is out-of-date with
  256.  
  257.  
  258.  
  259.                                                                         PPPPaaaaggggeeee 4444
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  267.  
  268.  
  269.  
  270.                respect to the sources on that line only.  In addition, the
  271.                target will not be removed if ppppmmmmaaaakkkkeeee is interrupted, unlike for
  272.                the other two operators.
  273.  
  274.      For example:
  275.         a :  a.o b.o c.o
  276.         b !  d.o e.o
  277.         c :: f.o
  278.              command1
  279.         a :  g.o
  280.         b !  h.o
  281.         c ::
  282.              command2
  283.      specifies that a depends on a.o, b.o, c.o and g.o and will be remade only
  284.      if out-of-date with respect to these four files. b depends on d.o, e.o
  285.      and h.o and will always be remade, but only after these three files have
  286.      been remade. c will be remade with command1 if it is out-of-date with
  287.      respect to f.o, as for the colon operator, while command2 will always be
  288.      executed.
  289.  
  290.      Targets and sources may also contain standard shell wildcard characters
  291.      (?, *, [ and {}), but the ?, *, [ and ] characters may only be used in
  292.      the final component of the target or source. If a target or source
  293.      contains only curly braces and no other wildcard characters, it need not
  294.      describe an existing file. Otherwise, only existing files will be used.
  295.      For example, the pattern
  296.         {a,b,c}.o
  297.      will expand to
  298.         a.o b.o c.o
  299.      regardless of whether these three files exist, while
  300.         [abc].o
  301.      will only expand to this if all three files exist. The resulting
  302.      expansion is in directory order, not alphabetically sorted as in the
  303.      shell.
  304.  
  305. CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
  306.      Associated with each target is a series of shell commands, collectively
  307.      called a script. The creation script for a target should immediately
  308.      follow the dependency line for that target.  Each of the commands in this
  309.      script _m_u_s_t be preceded by a tab character.
  310.  
  311.      While any given target may appear on more than one dependency line, only
  312.      one of these dependency lines may be followed by a creation script,
  313.      unless the "::" operator is used.
  314.  
  315.      One helpful feature of ppppmmmmaaaakkkkeeee is the ability to delay execution of a
  316.      target's commands until everything else has been done. To do this, make
  317.      one of the commands for the target be just ``...'' (an ellipsis) on a
  318.  
  319.  
  320.  
  321.                                                                         PPPPaaaaggggeeee 5555
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  329.  
  330.  
  331.  
  332.      line by itself. The ellipsis itself won't be executed, of course, but any
  333.      commands in the target's script that follow the ellipsis will be saved
  334.      until ppppmmmmaaaakkkkeeee is done processing everything it needs to process.  If you
  335.      were to say,
  336.         a.o : a.c
  337.              cc  -c  a.c
  338.              ...
  339.              @echo "All done"
  340.      Then the command ``echo "All done"'' would execute once everything else
  341.      had finished. Note that this will only happen if ``a.o'' is found to be
  342.      out-of-date.  Macros and variables in these delayed commands are
  343.      evaluated once at the time they would have executed and again when (at
  344.      the end) they are actually executed.  This means that shell variables,
  345.      which usually must be escaped with a `$' (as in `$$i') must now be
  346.      escaped twice (as in `$$$$i').
  347.  
  348.      There is another way in which makefile shell commands differ from regular
  349.      shell commands, as illustrated in the previous example.  The first two
  350.      characters after the initial tab (and any other white-space) are treated
  351.      specially. If they are any combination of `@' and `-', (``@'', ``@-'',
  352.      ``-@'' or ``-''), they cause ppppmmmmaaaakkkkeeee to do different things.
  353.  
  354.      In most cases, shell commands are printed to the screen before they're
  355.      actually executed. This is to keep you informed of what's going on. If an
  356.      `@' appears, however, this echoing is suppressed. In the case of the echo
  357.      command, above, this makes sense. It would look silly to see
  358.         echo "All done"
  359.         All done
  360.      so ppppmmmmaaaakkkkeeee allows you to avoid that (this sort of echo control is only
  361.      available if you use the Bourne or C shells to execute your commands,
  362.      since the commands are echoed by the shell, not by ppppmmmmaaaakkkkeeee).
  363.  
  364.      The other special character is the `-'.  Shell commands exit with a
  365.      certain ``exit status.''  Normally this status will be 0 if everything
  366.      went ok and non-zero if something went wrong. For this reason, ppppmmmmaaaakkkkeeee will
  367.      consider an error to have occurred if one of the commands it invokes
  368.      returns a non-zero status. When it detects an error, its usual action is
  369.      to stop working, wait for everything in process to finish, and exit with
  370.      a non-zero status itself.  This behavior can be altered, however, by
  371.      means of ----iiii or ----kkkk arguments, or by placing a `-' at the front of the
  372.      command.  (Another quick note: the decision of whether to abort a target
  373.      when one of its shell commands returns non-zero is left to the shell that
  374.      is executing the commands. Some shells allow this ``error-checking'' to
  375.      be switched on and off at will while others do not.)
  376.  
  377. VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS
  378.      ppppmmmmaaaakkkkeeee has the ability to save text in variables to be recalled later at
  379.      your convenience.  Variables in ppppmmmmaaaakkkkeeee are used much like variables in
  380.      _s_h(1) and, by tradition, consist of all upper-case letters.  (They can
  381.      also contain lower-case letters, numbers, and punctuation characters
  382.  
  383.  
  384.  
  385.                                                                         PPPPaaaaggggeeee 6666
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  393.  
  394.  
  395.  
  396.      except =, :, ) and }. # must be preceded with a backslash).  They are
  397.      assigned- and appended-to using lines of the form
  398.         _V_A_R_I_A_B_L_E   ==== _v_a_l_u_e
  399.         _V_A_R_I_A_B_L_E   ++++==== _v_a_l_u_e
  400.      respectively, while being conditionally assigned-to (if not already
  401.      defined) and assigned-to with expansion by lines of the form
  402.         _V_A_R_I_A_B_L_E   ????==== _v_a_l_u_e
  403.         _V_A_R_I_A_B_L_E   ::::==== _v_a_l_u_e
  404.      With ::::====, any variable on the right-hand side will be replaced with its
  405.      current definition. Put at least one blank between the end of the
  406.      variable name and the assignment operator.  Finally,
  407.         _V_A_R_I_A_B_L_E   !!!!==== _c_o_m_m_a_n_d
  408.      will execute _c_o_m_m_a_n_d using the Bourne shell and place the result in the
  409.      given variable.  Newlines are converted to spaces before the assignment
  410.      is made. This is not intended to be used with commands that produce a
  411.      large amount of output. If you use it this way, ppppmmmmaaaakkkkeeee will probably
  412.      deadlock.  A particularly useful example of this is:
  413.         OSVERS!=uname -r | sed 'y/\./\_/' | cut -c1-3
  414.      which will set the variable _OOOO_SSSS_VVVV_EEEE_RRRR_SSSS to the major and minor release of the
  415.      current system, separated by an underscore.
  416.  
  417.      Variables are expanded by enclosing the variable name in either
  418.      parentheses or curly braces and preceding the whole thing with a dollar
  419.      sign.  For example, to set the variable CCCCFFFFLLLLAAAAGGGGSSSS to the string
  420.      ``-I../hdrs  -O'' place the line
  421.         CFLAGS = -I../hdrs  -O
  422.      in the makefile and use the word $$$$((((CCCCFFFFLLLLAAAAGGGGSSSS)))) wherever you would like the
  423.      string ``-I../hdrs  -O'' to appear.  To pass a string of the form
  424.      ``$(_n_a_m_e)'' or ``${_n_a_m_e}'' through to the shell (e.g., to tell it to
  425.      substitute one of its variables), you can use ``$$(_n_a_m_e)'' and
  426.      ``$${_n_a_m_e}'', respectively, or, as long as the _n_a_m_e is not a ppppmmmmaaaakkkkeeee
  427.      variable, you can just place the string in directly, as ppppmmmmaaaakkkkeeee will not
  428.      expand a variable it doesn't know, unless it is given one of the three
  429.      compatibility flags ----VVVV, ----BBBB, or ----MMMM, or invoked as _ssss_mmmm_aaaa_kkkk_eeee.
  430.  
  431.      There are two distinct times at which variable substitution occurs:  When
  432.      parsing a dependency line, such substitution occurs immediately upon
  433.      reading the line.  Thus all variables used in dependency lines must be
  434.      defined before they appear on any dependency line.  For variables that
  435.      appear in shell commands, variable substitution occurs when the command
  436.      is processed, that is, when it is prepared to be passed to the shell or
  437.      before being saved for later execution (see CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS above).
  438.  
  439.      There are four different types of variables at which ppppmmmmaaaakkkkeeee will look when
  440.      trying to expand any given variable.  They are (in order of decreasing
  441.      precedence): (1) variables that are defined specific to a certain target.
  442.  
  443.  
  444.  
  445.                                                                         PPPPaaaaggggeeee 7777
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  453.  
  454.  
  455.  
  456.      These are the so-called ``local'' variables and will only be used when
  457.      performing variable substitution on the target's shell script and in
  458.      dynamic sources (see below for more details), (2) variables that were
  459.      defined on the command line, (3) variables defined in the makefile and
  460.      (4) those defined in ppppmmmmaaaakkkkeeee's environment, as passed by your login shell.
  461.      An important side effect of this searching order is that once you define
  462.      a variable on the command line, _n_o_t_h_i_n_g in the makefile can change it.
  463.  
  464.      The _SSSS_HHHH_EEEE_LLLL_LLLL macro is treated specially. It is automatically set by ppppmmmmaaaakkkkeeee at
  465.      the start to be /_b_i_n/_s_h.  The value of the environment variable _SSSS_HHHH_EEEE_LLLL_LLLL
  466.      does not affect the value of the _SSSS_HHHH_EEEE_LLLL_LLLL macro.  If the _SSSS_HHHH_EEEE_LLLL_LLLL macro is
  467.      defined in the makefile or on the command line it replaces the original
  468.      value (and changes the shell used for all commands), but does NOT affect
  469.      the _SSSS_HHHH_EEEE_LLLL_LLLL environment variable.
  470.  
  471.      As mentioned above, each target has associated with it as many as seven
  472.      ``local'' variables. Four of these variables are always set for every
  473.      target that must be recreated. Each local variable has a long, meaningful
  474.      name and a short, one-character name that exists for backwards-
  475.      compatibility.  They are:
  476.  
  477.           .TARGET  (@)        The name of the target.
  478.  
  479.           .OODATE  (?)        The list of sources for this target that were
  480.                               deemed out-of-date.
  481.  
  482.           .ALLSRC  (>)        The list of all sources for this target.
  483.  
  484.           .PREFIX  (*)        The file prefix of the file. This contains only
  485.                               the file portion - no suffix or leading
  486.                               directory components.
  487.  
  488.      Three other ``local'' variables are set only for certain targets under
  489.      special circumstances. These are the ``.IMPSRC'', ``.ARCHIVE'' and
  490.      ``.MEMBER'' variables. When they are set, how they are used, and what
  491.      their short forms are detailed in later sections.
  492.  
  493.      In addition, for System V Make compatibility, the variables ``@F'',
  494.      ``<F'', and ``*F'' are defined as the file parts of the ``@'', ``>'' and
  495.      ``*'' variables.  Likewise, ``@D'', ``<D'', and ``*D'' are directory
  496.      parts.
  497.  
  498.      Four of these local variables may be used in sources on dependency lines.
  499.      The variables expand to the proper value for each target on the line. The
  500.      variables are ``.TARGET'', ``.PREFIX'', ``.ARCHIVE'', and ``.MEMBER''.
  501.  
  502.      In addition, certain variables are set by or have special meaning to
  503.      ppppmmmmaaaakkkkeeee.  The ....PPPPMMMMAAAAKKKKEEEE (and MMMMAAAAKKKKEEEE)))) variable is set to the name by which ppppmmmmaaaakkkkeeee
  504.      was invoked, to allow recursive makes to use the same version, whatever
  505.      it may be.  All command-line flags given to ppppmmmmaaaakkkkeeee are stored in the
  506.      ....MMMMAAAAKKKKEEEEFFFFLLLLAAAAGGGGSSSS (and MMMMFFFFLLLLAAAAGGGGSSSS)))) variable just as they were given. This variable
  507.      is also exported to subshells as the PPPPMMMMAAAAKKKKEEEE environment variable.
  508.  
  509.  
  510.  
  511.                                                                         PPPPaaaaggggeeee 8888
  512.  
  513.  
  514.  
  515.  
  516.  
  517.  
  518. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  519.  
  520.  
  521.  
  522.      Variable expansion may be modified as for the C shell. A general
  523.      expansion specification looks like:
  524.         $$$$((((_v_a_r_i_a_b_l_e[::::_m_o_d_i_f_i_e_r[::::...]]))))
  525.      Each modifier begins with a single character, thus:
  526.  
  527.           M_p_a_t_t_e_r_n
  528.                This is used to select only those words (a word is a series of
  529.                characters that are neither spaces nor tabs) that match the
  530.                given _p_a_t_t_e_r_n . The pattern is a wildcard pattern like that
  531.                used by the shell, where "*" means 0 or more characters of any
  532.                sort; "?" is any single character; "[abcd]" matches any single
  533.                character that is either `a', `b', `c' or `d' (there may be any
  534.                number of characters between the brackets); [[[[0000----9999]]]] matches any
  535.                single character that is between `0' and `9' (i.e., any digit.
  536.                This form may be freely mixed with the other bracket form), and
  537.                \ is used to escape any of the characters "*", "?", "[" or ":",
  538.                leaving them as regular characters to match themselves in a
  539.                word.  For example, the system makefile <makelint.mk> uses
  540.                $(CFLAGS:M-[ID]*) to extract all the ----IIII and ----DDDD C compiler flags
  541.                for _l_i_n_t.
  542.  
  543.           N_p_a_t_t_e_r_n
  544.                This is identical to ":M" except it substitutes all words that
  545.                don't match the given pattern.
  546.  
  547.           S/_s_e_a_r_c_h-_s_t_r_i_n_g/_r_e_p_l_a_c_e_m_e_n_t-_s_t_r_i_n_g/[g]
  548.                Causes the first occurrence of _s_e_a_r_c_h-_s_t_r_i_n_g in the variable to
  549.                be replaced by _r_e_p_l_a_c_e_m_e_n_t-_s_t_r_i_n_g, unless the "g" flag is given
  550.                at the end, in which case all occurrences of the string are
  551.                replaced. The substitution is performed on each word in the
  552.                variable in turn. If _s_e_a_r_c_h-_s_t_r_i_n_g begins with a "^", the
  553.                string must match starting at the beginning of the word. If
  554.                _s_e_a_r_c_h-_s_t_r_i_n_g ends with a "$", the string must match to the end
  555.                of the word (these two may be combined to force an exact
  556.                match). If a backslash precedes these two characters, however,
  557.                they lose their special meaning. Variable expansion also occurs
  558.                in the normal fashion inside both the _s_e_a_r_c_h-_s_t_r_i_n_g and the
  559.                _r_e_p_l_a_c_e_m_e_n_t-_s_t_r_i_n_g, eeeexxxxcccceeeepppptttt that a backslash is used to prevent
  560.                the expansion of a "$", not another dollar sign, as is usual.
  561.                Note that _s_e_a_r_c_h-_s_t_r_i_n_g is just a string, not a pattern, so
  562.                none of the usual regular-expression/wildcard characters has
  563.                any special meaning save "^" and "$".  In the replacement
  564.                string, the "&" character is replaced by the _s_e_a_r_c_h-_s_t_r_i_n_g
  565.                unless it is preceded by a backslash.  You are allowed to use
  566.                any character except colon or exclamation point to separate the
  567.                two strings. This so-called delimiter character may be placed
  568.                in either string by preceding it with a backslash.
  569.  
  570.           T    Replaces each word in the variable expansion by its last
  571.                component (its ``tail''). For example, given
  572.                   OBJS = ../lib/a.o  b  /usr/lib/libm.a
  573.  
  574.  
  575.                                                                         PPPPaaaaggggeeee 9999
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  583.  
  584.  
  585.  
  586.                   TAILS = $(OBJS:T)
  587.                the variable TAILS would expand to ``a.o  b  libm.a''.
  588.  
  589.           H    This is similar to ":T", except that every word is replaced by
  590.                everything but the tail (the ``head''). Using the same
  591.                definition of OBJS from above, the string ``$(OBJS:H)'' would
  592.                expand to ``../lib  /usr/lib''.  Note that the final slash on
  593.                the heads is removed and anything without a head is replaced by
  594.                the empty string.
  595.  
  596.           E    ":E" replaces each word by its suffix (``extension'').  For
  597.                example, ``$(OBJS:E)'' would give you ``.o  .a''.
  598.  
  599.           R    This replaces each word by everything but the suffix (the
  600.                ``root'' of the word).  For example, ``$(OBJS:R)'' would give
  601.                you ``../lib/a  b  /usr/lib/libm''.
  602.  
  603.      In addition, ppppmmmmaaaakkkkeeee supports the System V form of substitution
  604.         $$$$((((_v_a_r_i_a_b_l_e::::_s_t_r_i_n_g_1====_s_t_r_i_n_g_2))))
  605.      where all occurrences of _s_t_r_i_n_g_1 at the end of each word in the variable
  606.      expansion are replaced by _s_t_r_i_n_g_2.
  607.  
  608. CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS,,,, IIIINNNNCCCCLLLLUUUUSSSSIIIIOOOONNNN AAAANNNNDDDD CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLLSSSS
  609.      Makefile inclusion and conditional structures reminiscent of the C
  610.      compiler have also been included in ppppmmmmaaaakkkkeeee.
  611.  
  612.      Comments begin with a `#' anywhere but in a shell command and continue to
  613.      the end of the line. The comment character can included in macros if
  614.      preceded with a backslash (\).  If the `#' comes at the beginning of the
  615.      line, however, the following keywords are recognized and acted on:
  616.  
  617.    ####iiiinnnncccclllluuuuddddeeee """"_m_a_k_e_f_i_l_e""""
  618.    ####iiiinnnncccclllluuuuddddeeee <<<<_s_y_s_t_e_m _m_a_k_e_f_i_l_e>>>>
  619.      This is very similar to the C compiler's file-inclusion facility, right
  620.      down to the syntax.  What follows the ####iiiinnnncccclllluuuuddddeeee must be a filename
  621.      enclosed either in double-quotes or angle brackets.  Variables will be
  622.      expanded between the double-quotes or angle-brackets.  If angle-brackets
  623.      are used, the system makefile directory is searched.  If the name is
  624.      enclosed in double-quotes, the including makefile's directory, followed
  625.      by all directories given via ----IIII arguments, followed by the system
  626.      directory, is searched for a file of the given name.
  627.  
  628.      If the file is found, ppppmmmmaaaakkkkeeee starts taking input from that file as if it
  629.      were part of the original makefile.
  630.  
  631.      When the end of the file is reached, ppppmmmmaaaakkkkeeee goes back to the previous file
  632.      and continues from where it left off.  This facility is recursive up to a
  633.      depth limited only by the number of open files allowed to any process at
  634.      one time.
  635.  
  636.  
  637.  
  638.                                                                        PPPPaaaaggggeeee 11110000
  639.  
  640.  
  641.  
  642.  
  643.  
  644.  
  645. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  646.  
  647.  
  648.  
  649.    iiiinnnncccclllluuuuddddeeee _m_a_k_e_f_i_l_e
  650.    ssssiiiinnnncccclllluuuuddddeeee _m_a_k_e_f_i_l_e
  651.      This (non-standard) include syntax is recognized for compatibility with
  652.      the IRIX mmmmaaaakkkkeeee(1) command.  No search paths are used.  The file name may
  653.      contain variables.  For ``include'', it is a fatal error if the file is
  654.      not readable; for ``sinclude'', a non-readable file is silently ignored.
  655.  
  656.    ####iiiiffff [[[[!!!!]]]] _e_x_p_r [[[[ _o_p _e_x_p_r ............ ]]]]
  657.    ####iiiiffffddddeeeeffff [[[[!!!!]]]] _v_a_r_i_a_b_l_e [[[[_o_p _v_a_r_i_a_b_l_e............]]]]
  658.    ####iiiiffffnnnnddddeeeeffff [[[[!!!!]]]] _v_a_r_i_a_b_l_e [[[[_o_p _v_a_r_i_a_b_l_e............]]]]
  659.    ####iiiiffffmmmmaaaakkkkeeee [[[[!!!!]]]] _t_a_r_g_e_t [[[[_o_p _t_a_r_g_e_t............]]]]
  660.    ####iiiiffffnnnnmmmmaaaakkkkeeee [[[[!!!!]]]] _t_a_r_g_e_t [[[[_o_p _t_a_r_g_e_t............]]]]
  661.      These are all the beginnings of conditional constructs in the spirit of
  662.      the C compiler.  Conditionals may be nested to a depth of thirty.
  663.  
  664.      In the expressions given above, _o_p may be either |||||||| (logical OR) or &&&&&&&&
  665.      (logical AND).  &&&&&&&& has a higher precedence than ||||||||.  As in C, ppppmmmmaaaakkkkeeee will
  666.      evaluate an expression only as far as necessary to determine its value.
  667.      If the left side of an &&&&&&&& is false, the expression is false and vice
  668.      versa for ||||||||.  Parentheses may be used as usual to change the order of
  669.      evaluation.
  670.  
  671.      One other boolean operator is provided: !!!! (logical negation). It is of a
  672.      higher precedence than either the AND or OR operators, and may be applied
  673.      in any of the ``if'' constructs, negating the given function for ``#if''
  674.      or the implicit function for the other four.
  675.  
  676.      _E_x_p_r can be one of several things. Four functions are provided, each of
  677.      which takes a different sort of argument.
  678.  
  679.      The function _d_e_f_i_n_e_d is used to test for the existence of a variable.
  680.      Its argument is, therefore, a variable name.  Certain variable names
  681.      (e.g., ``IRIX'', ``SYSV'', and ``unix'') are defined in the system
  682.      makefile (see FFFFIIIILLLLEEEESSSS) to specify the sort of system on which ppppmmmmaaaakkkkeeee is
  683.      being run. These are intended to make makefiles more portable.  Any
  684.      variable may be used as the argument of the ddddeeeeffffiiiinnnneeeedddd function.
  685.  
  686.      The mmmmaaaakkkkeeee function is given the name of a target in the makefile and
  687.      evaluates to true if the target was given on ppppmmmmaaaakkkkeeee's command-line or as a
  688.      source for the ....MMMMAAAAIIIINNNN target before the line containing the conditional.
  689.  
  690.      The _e_x_i_s_t_s function takes a file name, which file is searched for on the
  691.      system search path (as defined by ....PPPPAAAATTTTHHHH targets (see below)). It
  692.      evaluates true if the file is found.
  693.  
  694.      The function _e_m_p_t_y takes a variable expansion specification (minus the
  695.      dollar sign) as its argument. If the resulting expansion is empty, this
  696.      evaluates true.
  697.  
  698.      _E_x_p_r can also be an arithmetic or string comparison, with the left-hand
  699.      side being a variable.  The standard C relational operators are allowed,
  700.      and the usual number/base conversion is performed, with the exception
  701.  
  702.  
  703.  
  704.                                                                        PPPPaaaaggggeeee 11111111
  705.  
  706.  
  707.  
  708.  
  709.  
  710.  
  711. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  712.  
  713.  
  714.  
  715.      that octal numbers are not supported. If the right-hand side of a "==" or
  716.      "!=" operator begins with a quotation mark, a string comparison is done
  717.      between the expanded variable and the text between the quotation marks.
  718.  
  719.      If no relational operator is given, the expression must be a single
  720.      variable, which is interpreted as a boolean. If the variable evaluates to
  721.      a 0 value, the expression is false and if it evaluates to a non-zero
  722.      value, the expression is true.
  723.  
  724.      When, in the course of evaluating one of these conditional expressions,
  725.      ppppmmmmaaaakkkkeeee encounters some word it does not recognize, it applies one of
  726.      either _m_a_k_e or _d_e_f_i_n_e_d to it, depending on the form of ``if'' used. For
  727.      example, ``#ifdef'' will apply the _d_e_f_i_n_e_d function, while ``#ifnmake''
  728.      will apply the negation of the _m_a_k_e function.
  729.  
  730.      If the expression following one of these forms evaluates true, the
  731.      reading of the makefile continues as before. If it evaluates false, the
  732.      following lines are skipped. In both cases, this continues until either
  733.      an ####eeeellllsssseeee or an ####eeeennnnddddiiiiffff line is encountered.
  734.  
  735.    ####eeeellllsssseeee
  736.      The #else, as in the C compiler, causes the sense of the last conditional
  737.      to be inverted and the reading of the makefile to be based on this new
  738.      value, i.e., if the previous expression evaluated true, the parsing of
  739.      the makefile is suspended until an #endif line is read.  If the previous
  740.      expression evaluated false, the parsing of the makefile is resumed.
  741.  
  742.    ####eeeelllliiiiffff [[[[!!!!]]]] _e_x_p_r [[[[ _o_p _e_x_p_r ............ ]]]]
  743.    ####eeeelllliiiiffffddddeeeeffff [[[[!!!!]]]] _v_a_r_i_a_b_l_e [[[[_o_p _v_a_r_i_a_b_l_e............]]]]
  744.    ####eeeelllliiiiffffnnnnddddeeeeffff [[[[!!!!]]]] _v_a_r_i_a_b_l_e [[[[_o_p _v_a_r_i_a_b_l_e............]]]]
  745.    ####eeeelllliiiiffffmmmmaaaakkkkeeee [[[[!!!!]]]] _t_a_r_g_e_t [[[[_o_p _t_a_r_g_e_t............]]]]
  746.    ####eeeelllliiiiffffnnnnmmmmaaaakkkkeeee [[[[!!!!]]]] _t_a_r_g_e_t [[[[_o_p _t_a_r_g_e_t............]]]]
  747.      The ``elif'' constructs are a combination of ``else'' and ``if,'' as the
  748.      name implies. If the preceding ``if'' evaluated false, the expression
  749.      following the ``elif'' is evaluated and the lines following it are read
  750.      or ignored the same as for a regular ``if.''  If the preceding ``if''
  751.      evaluated true, however, the ``elif'' is ignored and all following lines
  752.      until the ``endif'' (see below) are ignored.
  753.  
  754.    ####eeeennnnddddiiiiffff
  755.      ####eeeennnnddddiiiiffff is used to end a conditional section. If lines were being skipped,
  756.      the reading of the makefile resumes. Otherwise, it has no effect (the
  757.      makefile continues to be parsed as it was just before the ####eeeennnnddddiiiiffff was
  758.      encountered).
  759.  
  760.    ####uuuunnnnddddeeeeffff
  761.      Takes the next word on the line as a global variable to be undefined
  762.      (only undefines global variables, not command-line variables). If the
  763.      variable is already undefined, no message is generated.
  764.  
  765.  
  766.  
  767.  
  768.  
  769.  
  770.                                                                        PPPPaaaaggggeeee 11112222
  771.  
  772.  
  773.  
  774.  
  775.  
  776.  
  777. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  778.  
  779.  
  780.  
  781. TTTTAAAARRRRGGGGEEEETTTT AAAATTTTTTTTRRRRIIIIBBBBUUUUTTTTEEEESSSS
  782.      In ppppmmmmaaaakkkkeeee, files can have certain ``attributes.''  These attributes cause
  783.      ppppmmmmaaaakkkkeeee to treat the targets in special ways. An attribute is a special
  784.      word given as a source to a target on a dependency line. The words and
  785.      their functions are given below:
  786.  
  787.      .DONTCARE    If a target is marked with this attribute and ppppmmmmaaaakkkkeeee can't
  788.                   figure out how to create it, it will ignore this fact and
  789.                   assume the file isn't really needed or actually exists and
  790.                   ppppmmmmaaaakkkkeeee just can't find it.  (_...._OOOO_PPPP_TTTT_IIII_OOOO_NNNN_AAAA_LLLL is a synonym for
  791.                   _...._DDDD_OOOO_NNNN_TTTT_CCCC_AAAA_RRRR_EEEE.)
  792.  
  793.      .EXEC        This causes the marked target's shell script to always be
  794.                   executed (unless the ----nnnn or ----tttt flag is given), but appear
  795.                   invisible to any targets that depend on it.
  796.  
  797.      .IGNORE      Giving a target the ....IIIIGGGGNNNNOOOORRRREEEE attribute causes ppppmmmmaaaakkkkeeee to ignore
  798.                   errors from any of the target's commands, as if they all had
  799.                   `-' before them.
  800.  
  801.      .INVISIBLE   This allows you to specify one target as a source for
  802.                   another without the one affecting the other's local
  803.                   variables.
  804.  
  805.      .JOIN        This forces the target's shell script to be executed only if
  806.                   one or more of the sources was out-of-date. In addition, the
  807.                   target's name, in both its ....TTTTAAAARRRRGGGGEEEETTTT variable and all the
  808.                   local variables of any target that depends on it, is
  809.                   replaced by the value of its ....AAAALLLLLLLLSSSSRRRRCCCC variable.  Another
  810.                   aspect of the _...._JJJJ_OOOO_IIII_NNNN attribute is it keeps the target from
  811.                   being created if the ----tttt flag was given.
  812.  
  813.      .MAKE        The ....MMMMAAAAKKKKEEEE attribute marks its target as being a recursive
  814.                   invocation of ppppmmmmaaaakkkkeeee .  This forces ppppmmmmaaaakkkkeeee to execute the
  815.                   script associated with the target (if it is out-of-date)
  816.                   even if you gave the ----nnnn or ----tttt flag.
  817.  
  818.      .NOTMAIN     Normally, if you do not specify a target to make in any
  819.                   other way, ppppmmmmaaaakkkkeeee will take the first target on the first
  820.                   dependency line of a makefile as the target to create.
  821.                   Giving a target this attribute keeps it from this fate.
  822.  
  823.      .PRECIOUS    When ppppmmmmaaaakkkkeeee is interrupted, it will attempt to clean up after
  824.                   itself by removing any half-made targets. If a target has
  825.                   this attribute, however, ppppmmmmaaaakkkkeeee will leave it alone
  826.  
  827.      .SILENT      Marking a target with this attribute keeps its commands from
  828.                   being printed when they're executed.
  829.  
  830.      .USE         By giving a target this attribute, you turn the target into
  831.                   ppppmmmmaaaakkkkeeee's equivalent of a macro. When the target is used as a
  832.                   source for another target, the other target acquires the
  833.  
  834.  
  835.  
  836.                                                                        PPPPaaaaggggeeee 11113333
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  844.  
  845.  
  846.  
  847.                   commands, sources and attributes (except ....UUUUSSSSEEEE) of the
  848.                   source.  If the target already has commands, the ....UUUUSSSSEEEE
  849.                   target's commands are added to the end. If more than one
  850.                   _...._UUUU_SSSS_EEEE-marked source is given to a target, the rules are
  851.                   applied sequentially.
  852.  
  853.      The following target attributes are recognized but not implemented on
  854.      IRIX: .EXPORT, .EXPORTSAME, and .NOEXPORT.
  855.  
  856. SSSSPPPPEEEECCCCIIIIAAAALLLL TTTTAAAARRRRGGGGEEEETTTTSSSS
  857.      As there were in mmmmaaaakkkkeeee(1), so there are certain targets that have special
  858.      meaning to ppppmmmmaaaakkkkeeee . When you use one on a dependency line, it is the only
  859.      target that may appear on the left-hand-side of the operator.  The
  860.      targets are as follows:
  861.  
  862.      .BEGIN      Any commands attached to this target are executed before
  863.                  anything else is done. You can use it for any initialization
  864.                  that needs doing.
  865.  
  866.      .DEFAULT    This is sort of a .USE rule for any target (that was used
  867.                  only as a source) that ppppmmmmaaaakkkkeeee can't figure out any other way
  868.                  to create. Only the shell script is used. The ....IIIIMMMMPPPPSSSSRRRRCCCC
  869.                  variable of a target that inherits ....DDDDEEEEFFFFAAAAUUUULLLLTTTT's commands is set
  870.                  to the target's own name.
  871.  
  872.      .END        This serves a function similar to ....BBBBEEEEGGGGIIIINNNN:  commands attached
  873.                  to it are executed once everything has been recreated (so
  874.                  long as no errors occurred). It also serves the extra
  875.                  function of being a place on which ppppmmmmaaaakkkkeeee can hang commands
  876.                  you put off to the end. Thus the script for this target will
  877.                  be executed before any of the commands you save with the
  878.                  ``...''.
  879.  
  880.      .IGNORE     This target marks each of its sources with the ....IIIIGGGGNNNNOOOORRRREEEE
  881.                  attribute. If you don't give it any sources, then it is like
  882.                  giving the ----iiii flag.
  883.  
  884.      .INCLUDES   The sources for this target are taken to be suffixes that
  885.                  indicate a file that can be included in a program source
  886.                  file.  The suffix must have already been declared with
  887.                  ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS (see below).  Any suffix so marked will have the
  888.                  directories on its search path (see ....PPPPAAAATTTTHHHH, below) placed in
  889.                  the ....IIIINNNNCCCCLLLLUUUUDDDDEEEESSSS variable, each preceded by a ----IIII flag. The ....hhhh
  890.                  suffix is already marked in this way in the system makefile.
  891.  
  892.      .INTERRUPT  When ppppmmmmaaaakkkkeeee is interrupted, it will execute the commands in
  893.                  the script for this target, if it exists.
  894.  
  895.      .LIBS       This does for libraries what ....IIIINNNNCCCCLLLLUUUUDDDDEEEESSSS does for include
  896.                  files, except the flag used is ----LLLL, as required by those
  897.                  linkers that allow you to tell them where to find libraries.
  898.                  The variable used is ....LLLLIIIIBBBBSSSS.
  899.  
  900.  
  901.  
  902.                                                                        PPPPaaaaggggeeee 11114444
  903.  
  904.  
  905.  
  906.  
  907.  
  908.  
  909. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  910.  
  911.  
  912.  
  913.      .MAIN       If you didn't give a target (or targets) to create when you
  914.                  invoked ppppmmmmaaaakkkkeeee , it will take the sources of this target as
  915.                  the targets to create.
  916.  
  917.      .MAKEFLAGS  This target provides a way for you to always specify flags
  918.                  for ppppmmmmaaaakkkkeeee when the makefile is used. The flags are just as
  919.                  they would be typed to the shell, though the ----ffff and ----rrrr flags
  920.                  have no effect.
  921.  
  922.      .NOTPARALLEL
  923.                  This is used to make only one target at a time.  It is
  924.                  equivalent to giving the ----JJJJ  1111 flag.
  925.  
  926.      .NULL       This allows you to specify what suffix ppppmmmmaaaakkkkeeee should pretend a
  927.                  file has if, in fact, it has no known suffix. Only one suffix
  928.                  may be so designated. The last source on the dependency line
  929.                  is the suffix that is used (you should, however, only give
  930.                  one suffix).
  931.  
  932.      .ORDER      Sources for this target, which are targets themselves, are
  933.                  made in the specified order.  This feature only works in the
  934.                  simplest of cases, and is never applied if the listed target
  935.                  is a 'main' target (i.e. listed on the command line).  This
  936.                  feature does not interact well with '::' rules.
  937.  
  938.      .PATH       If you give sources for this target, ppppmmmmaaaakkkkeeee will take them as
  939.                  directories to search for files it cannot find in the current
  940.                  directory. If you give no sources, it will clear out any
  941.                  directories added to the search path before.
  942.  
  943.      .PATH_s_u_f_f_i_x This does a similar thing to ....PPPPAAAATTTTHHHH, but it does it only for
  944.                  files with the given suffix. The suffix must have been
  945.                  defined already.
  946.  
  947.      .PRECIOUS   Gives the ....PPPPRRRREEEECCCCIIIIOOOOUUUUSSSS attribute to each source on the
  948.                  dependency line, unless there are no sources, in which case
  949.                  the ....PPPPRRRREEEECCCCIIIIOOOOUUUUSSSS attribute is given to every target in the file.
  950.  
  951.      .RECURSIVE  Applies the ....MMMMAAAAKKKKEEEE attribute to all its sources. It does
  952.                  nothing if you don't give it any sources.
  953.  
  954.      .SHELL      Tells ppppmmmmaaaakkkkeeee to use some other shell than the Bourne Shell.
  955.                  The sources for the target are organized as _k_e_y_w_o_r_d====_v_a_l_u_e
  956.                  strings. If a _v_a_l_u_e contains white-space, it may be
  957.                  surrounded by double-quotes to make it a single word.  Be
  958.                  sure to have at least one space between the ':' and the start
  959.                  of the first keyword/value string.  The possible sources are:
  960.  
  961.                  ppppaaaatttthhhh====_p_a_t_h
  962.                       Tells where the shell actually resides. If you specify
  963.                       this and nothing else, ppppmmmmaaaakkkkeeee will use the last component
  964.                       of the path to find the specification. Use this if you
  965.  
  966.  
  967.  
  968.                                                                        PPPPaaaaggggeeee 11115555
  969.  
  970.  
  971.  
  972.  
  973.  
  974.  
  975. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  976.  
  977.  
  978.  
  979.                       just want to use a different version of the Bourne or C
  980.                       Shell (ppppmmmmaaaakkkkeeee knows how to use the C Shell too).
  981.  
  982.                  nnnnaaaammmmeeee====_n_a_m_e
  983.                       This is the name by which the shell is to be known. It
  984.                       is a single word and, if no other keywords are specified
  985.                       (other than ppppaaaatttthhhh), it is the name by which ppppmmmmaaaakkkkeeee
  986.                       attempts to find a specification for the it. You can use
  987.                       this if you would just rather use the C Shell than the
  988.                       Bourne Shell (``....SSSSHHHHEEEELLLLLLLL:::: nnnnaaaammmmeeee====ccccsssshhhh'' will do it).
  989.                       Similarly, use the name ``ksh'' for the Korn Shell and
  990.                       ``tcsh'' for the 'totally-cool' version of C Shell.
  991.  
  992.                  qqqquuuuiiiieeeetttt====_e_c_h_o-_o_f_f _c_o_m_m_a_n_d
  993.                       The command ppppmmmmaaaakkkkeeee should send to stop the shell from
  994.                       printing its commands. Once echoing is off, it is
  995.                       expected to remain off until explicitly turned on.
  996.  
  997.                  eeeecccchhhhoooo====_e_c_h_o-_o_n _c_o_m_m_a_n_d
  998.                       The command ppppmmmmaaaakkkkeeee should give to turn echoing back on
  999.                       again.
  1000.  
  1001.                  ffffiiiilllltttteeeerrrr====_p_r_i_n_t_e_d _e_c_h_o-_o_f_f _c_o_m_m_a_n_d
  1002.                       Many shells will echo the echo-off command when it is
  1003.                       given. This keyword tells ppppmmmmaaaakkkkeeee in what format the shell
  1004.                       actually prints the echo-off command. Wherever ppppmmmmaaaakkkkeeee
  1005.                       sees this string in the shell's output, it will delete
  1006.                       it and any following white-space, up to and including
  1007.                       the next newline.
  1008.  
  1009.                  eeeecccchhhhooooFFFFllllaaaagggg====_f_l_a_g _t_o _t_u_r_n _e_c_h_o_i_n_g _o_n
  1010.                       The flag to pass to the shell to turn echoing on at the
  1011.                       start.  If either this or the next flag begins with a
  1012.                       `-', the flags will be passed to the shell as separate
  1013.                       arguments. Otherwise, the two will be concatenated.
  1014.  
  1015.                  eeeerrrrrrrrFFFFllllaaaagggg====_f_l_a_g _t_o _t_u_r_n _e_r_r_o_r _c_h_e_c_k_i_n_g _o_n
  1016.                       Flag to give the shell to turn error checking on at the
  1017.                       start.
  1018.  
  1019.                  cccchhhheeeecccckkkk====_c_o_m_m_a_n_d _t_o _t_u_r_n _e_r_r_o_r _c_h_e_c_k_i_n_g _o_n
  1020.                       The command to make the shell check for errors or to
  1021.                       print the command that's about to be executed (%s
  1022.                       indicates where the command to print should go), if
  1023.                       hasErrCtl is "no".
  1024.  
  1025.                  iiiiggggnnnnoooorrrreeee====_c_o_m_m_a_n_d _t_o _t_u_r_n _e_r_r_o_r _c_h_e_c_k_i_n_g _o_f_f
  1026.                       The command to turn error checking off or the command to
  1027.                       execute a command ignoring any errors. "%s" takes the
  1028.                       place of the command.
  1029.  
  1030.  
  1031.  
  1032.  
  1033.  
  1034.                                                                        PPPPaaaaggggeeee 11116666
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040.  
  1041. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1042.  
  1043.  
  1044.  
  1045.                  hhhhaaaassssEEEErrrrrrrrCCCCttttllll====_y_e_s _o_r _n_o
  1046.                       This takes a value that is either yyyyeeeessss or nnnnoooo, telling how
  1047.                       the "check" and "ignore" commands should be used.  NOTE:
  1048.                       If this is "no", both the check and ignore commands
  1049.                       should contain a \n at their end if the shell requires a
  1050.                       newline before executing a command.
  1051.  
  1052.                  nnnnoooonnnniiiinnnntttteeeerrrrFFFFllllaaaagggg====_f_l_a_g _t_o _t_u_r_n _i_n_t_e_r_a_c_t_i_v_i_t_y _c_h_e_c_k_i_n_g _o_f_f
  1053.                       Flag to give the shell to turn force the shell into
  1054.                       non-interactive mode.
  1055.  
  1056.                  The strings that follow these keywords may be enclosed in
  1057.                  single or double quotes (the quotes will be stripped off) and
  1058.                  may contain the usual C backslash characters.
  1059.  
  1060.                  The built-in rule for using _cccc_ssss_hhhh will convince _cccc_ssss_hhhh to read the
  1061.                  _...._cccc_ssss_hhhh_rrrr_cccc file in 'interactive' mode - i.e. the standard test _iiii_ffff
  1062.                  _((((_$$$$_????_pppp_rrrr_oooo_mmmm_pppp_tttt_)))) will return true.  This may not be acceptable.
  1063.                  The only way around this is to specify a complete _cccc_ssss_hhhh shell
  1064.                  specification and specify the _----_ffff flag. This will simply tell
  1065.                  _cccc_ssss_hhhh to not read the _...._cccc_ssss_hhhh_rrrr_cccc at all.  The appropriate _SSSS_HHHH_EEEE_LLLL_LLLL
  1066.                  specification is:
  1067.                          .SHELL: path=/bin/csh \
  1068.                               name=csh \
  1069.                               noninterFlag=-f \
  1070.                               quiet="unset verbose" \
  1071.                               echo="set verbose" \
  1072.                               filter="unset verbose" \
  1073.                               echoFlag=v \
  1074.                               errFlag=e \
  1075.                               hasErrCtl=F \
  1076.                               check="echo \"%s\"\n" \
  1077.                               ignore="csh -c \"%s || exit 0\""
  1078.      .SILENT     Applies the ....SSSSIIIILLLLEEEENNNNTTTT attribute to each of its sources. If
  1079.                  there are no sources on the dependency line, then it is as if
  1080.                  you gave ppppmmmmaaaakkkkeeee the ----ssss flag.
  1081.  
  1082.      .SINGLESHELL
  1083.                  This is used to create a shell for each command.  It is
  1084.                  equivalent to giving the ----BBBB flag.
  1085.  
  1086.      .SUFFIXES   This is used to give new file suffixes for ppppmmmmaaaakkkkeeee to handle.
  1087.                  Each source is a suffix ppppmmmmaaaakkkkeeee should recognize. If you give a
  1088.                  ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS dependency line with no sources, ppppmmmmaaaakkkkeeee will forget
  1089.                  about all the suffixes it knew (this also clobbers the null
  1090.                  suffix).  For those targets that need to have suffixes
  1091.                  defined, this is how you do it.
  1092.  
  1093.  
  1094.  
  1095.  
  1096.  
  1097.  
  1098.                                                                        PPPPaaaaggggeeee 11117777
  1099.  
  1100.  
  1101.  
  1102.  
  1103.  
  1104.  
  1105. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1106.  
  1107.  
  1108.  
  1109.      In addition to these targets, a line of the form
  1110.         _a_t_t_r_i_b_u_t_e : _s_o_u_r_c_e_s
  1111.      applies the _a_t_t_r_i_b_u_t_e to all the targets listed as _s_o_u_r_c_e_s except as
  1112.      noted above.
  1113.  
  1114.      The .EXPORT target is recognized but not implemented on IRIX.
  1115.  
  1116. TTTTHHHHEEEE PPPPOOOOWWWWEEEERRRR OOOOFFFF SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS
  1117.      One of the best aspects of both mmmmaaaakkkkeeee(1) and ppppmmmmaaaakkkkeeee comes from their
  1118.      understanding of how the suffix of a file pertains to its contents and
  1119.      their ability to do things with a file based solely on its suffix.  ppppmmmmaaaakkkkeeee
  1120.      also has the ability to find a file based on its suffix, supporting
  1121.      different types of files being in different directories.  The former
  1122.      ability derives from the existence of so-called transformation rules
  1123.      while the latter comes from the specification of search paths using the
  1124.      ....PPPPAAAATTTTHHHH target.
  1125.  
  1126.    TTTTRRRRAAAANNNNSSSSFFFFOOOORRRRMMMMAAAATTTTIIIIOOOONNNN RRRRUUUULLLLEEEESSSS
  1127.      A special type of dependency, called a transformation rule, consists of a
  1128.      target made of two known suffixes stuck together followed by a shell
  1129.      script to transform a file of one suffix into a file of the other.  The
  1130.      first suffix is the suffix of the source file and the second is that of
  1131.      the target file.  For example, the target ``.c.o,'' followed by commands,
  1132.      would define a transformation from files with the ``.c'' suffix to those
  1133.      with the ``.o'' suffix.  A transformation rule has no source files
  1134.      associated with it, though attributes may be given to one in the usual
  1135.      way. These attributes are then applied to any target that is on the
  1136.      ``target end'' of a transformation rule.  The suffixes that are
  1137.      concatenated must be already known to ppppmmmmaaaakkkkeeee in order for their
  1138.      concatenation to be recognized as a transformation, i.e., the suffixes
  1139.      must have been the source for a .SUFFIXES target at some time before the
  1140.      transformation is defined.  Many transformations are defined in the
  1141.      system makefile (see FFFFIIIILLLLEEEESSSS), which you should examine for more examples
  1142.      as well as to find what is already available. (You should especially note
  1143.      the various variables used to contain flags for the compilers,
  1144.      assemblers, etc., used to transform the files. These variables allow you
  1145.      to customize the transformations to your own needs without having to
  1146.      redefine them.)  A transformation rule may be defined more than once, but
  1147.      only the last such definition is remembered by ppppmmmmaaaakkkkeeee.  This allows you to
  1148.      redefine the transformations in the system makefile if you wish.
  1149.  
  1150.      Transformation rules are used only when a target has no commands
  1151.      associated with it, both to find any additional files on which it depends
  1152.      and to attempt to figure out just how to make the target should it end up
  1153.      being out-of-date.  When a transformation is found for a target, another
  1154.      of the seven ``local'' variables mentioned earlier is defined:
  1155.  
  1156.           .IMPSRC  (<)        The name/path of the source from which the
  1157.                               target is to be transformed (the ``implied''
  1158.                               source).
  1159.  
  1160.  
  1161.  
  1162.  
  1163.                                                                        PPPPaaaaggggeeee 11118888
  1164.  
  1165.  
  1166.  
  1167.  
  1168.  
  1169.  
  1170. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1171.  
  1172.  
  1173.  
  1174.      For example, given the following makefile:
  1175.         a.out : a.o b.o
  1176.              $(CC) $(.ALLSRC)
  1177.      and a directory containing the files a.o, a.c and b.c, ppppmmmmaaaakkkkeeee will look at
  1178.      the list of suffixes and transformations given in the built-in rules and
  1179.      find that the suffixes ``.c'' and ``.o'' are both known and there is a
  1180.      transformation rule defined from one to the other with the command
  1181.      ``$(CC) $(CFLAGS) -c  $(.IMPSRC).''  Having found this, it can then check
  1182.      the modification times of both a.c and b.c and execute the command from
  1183.      the transformation rule as necessary in order to update the files a.o and
  1184.      b.o.
  1185.  
  1186.      ppppmmmmaaaakkkkeeee, unlike mmmmaaaakkkkeeee(1) before it, has the ability to apply several
  1187.      transformations to a file even if the intermediate files do not exist.
  1188.      Given a directory containing a .o file and a .v file, and transformations
  1189.      from .v to .w, .w to .c and .c to .o, ppppmmmmaaaakkkkeeee will define a transformation
  1190.      from .v -> .o using the three transformation rules you defined.  In the
  1191.      event of two paths between the same suffixes, the shortest path will be
  1192.      chosen between the target and the first existing file on the path.  So if
  1193.      there were also a transformation from .w files to .o files, ppppmmmmaaaakkkkeeee would
  1194.      use the path .v -> .w -> .o instead of .v -> .w -> .c -> .o.
  1195.  
  1196.      Once an existing file is found, ppppmmmmaaaakkkkeeee will continue to look at and record
  1197.      transformations until it comes to a file to which nothing it knows of can
  1198.      be transformed, at which point it will stop looking and use the path it
  1199.      has already found.
  1200.  
  1201.      What happens if you have a .o file, a .v file and a .r file, all with the
  1202.      same prefix, and transformations from .v -> .o and .r -> .o?  Which
  1203.      transformation will be used?  ppppmmmmaaaakkkkeeee uses the order in which the suffixes
  1204.      were given on the ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS line to decide between transformations:
  1205.      whichever suffix came first, wins.  So if the three suffixes were
  1206.      declared
  1207.         .SUFFIXES : .o .v .r
  1208.      the .v -> .o transformation would be applied. Similarly, if they were
  1209.      declared as
  1210.         .SUFFIXES : .o .r .v
  1211.      the .r -> .o transformation would be used.  You should keep this in mind
  1212.      when writing such rules.  Note also that because the placing of a suffix
  1213.      on a ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS line doesn't alter the precedence of previously-defined
  1214.      transformations, it is sometimes necessary to clear the whole lot of them
  1215.      out and start from scratch. This is what the ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS-only line,
  1216.      mentioned earlier, will do.
  1217.  
  1218. SSSSEEEEAAAARRRRCCCCHHHH PPPPAAAATTTTHHHHSSSS
  1219.      ppppmmmmaaaakkkkeeee also supports the notion of multiple directories in a more
  1220.      flexible, easily-used manner than has been available in the past.  You
  1221.      can define a list of directories in which to search for any and all files
  1222.      that aren't in the current directory by giving the directories as sources
  1223.  
  1224.  
  1225.  
  1226.                                                                        PPPPaaaaggggeeee 11119999
  1227.  
  1228.  
  1229.  
  1230.  
  1231.  
  1232.  
  1233. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1234.  
  1235.  
  1236.  
  1237.      to the ....PPPPAAAATTTTHHHH target. The search will only be conducted for those files
  1238.      used only as sources, on the assumption that files used as targets will
  1239.      be created in the current directory.
  1240.  
  1241.      The line
  1242.         .PATH : RCS
  1243.      would tell ppppmmmmaaaakkkkeeee to look for any files it is seeking (including ones made
  1244.      up by means of transformation rules) in the RCS directory as well as the
  1245.      current one. Note, however, that this searching is only done if the file
  1246.      is used only as a source in the makefile; the file cannot be created by
  1247.      commands in the makefile.
  1248.  
  1249.      A search path specific to files with a given suffix can also be specified
  1250.      in much the same way.
  1251.         .PATH.h :   h   /usr/include
  1252.      causes the search for header files to be conducted in the ``h'' and
  1253.      ``/usr/include'' directories as well as the current one.
  1254.  
  1255.      When expanding wildcards, these paths are also used. If the pattern has a
  1256.      recognizable suffix, the search path for that suffix is used.  Otherwise,
  1257.      the path defined with the regular ....PPPPAAAATTTTHHHH target is used.
  1258.  
  1259.      When a file is found somewhere other than the current directory, its name
  1260.      is replaced by its full pathname in any ``local'' variables.
  1261.  
  1262.      Two types of suffixes are given special attention when a search path is
  1263.      defined for them. On IRIX, the C compiler lets you specify where to find
  1264.      header files (.h files) by means of ----IIII flags similar to those used by
  1265.      ppppmmmmaaaakkkkeeee.  If a search path is given for any suffix used as a source for the
  1266.      ....IIIINNNNCCCCLLLLUUUUDDDDEEEESSSS target, the variable $$$$((((....IIIINNNNCCCCLLLLUUUUDDDDEEEESSSS)))) will be set to contain all
  1267.      the directories on the path, in the order given, in a format which can be
  1268.      passed directly to the C compiler.  Similarly, one may give directories
  1269.      to search for libraries to the compiler by means of ----LLLL flags.
  1270.      Directories on the search path for a suffix which was the source of the
  1271.      ....LLLLIIIIBBBBSSSS target will be placed in the $$$$((((....LLLLIIIIBBBBSSSS)))) variable ready to be passed
  1272.      to the compiler.
  1273.  
  1274. LLLLIIIIBBBBRRRRAAAARRRRIIIIEEEESSSS AAAANNNNDDDD AAAARRRRCCCCHHHHIIIIVVVVEEEESSSS
  1275.      Two other special forms of sources are recognized by ppppmmmmaaaakkkkeeee.  Any source
  1276.      that begins with the characters ``-l'' (lower-case L) or ends in a suffix
  1277.      that is a source for the ....LLLLIIIIBBBBSSSS target is assumed to be a library, and any
  1278.      source that contains a left parenthesis in it is considered to be a
  1279.      member (or members) of an archive.
  1280.  
  1281.      Libraries are treated specially mostly in how they appear in the local
  1282.      variables of those targets that depend on them. Since IRIX supports the
  1283.      ----LLLL flag when linking, the name of the library (i.e., its ``-l'' form) is
  1284.      used in all local variables.  ppppmmmmaaaakkkkeeee assumes that you will use the
  1285.      $(.LIBS) variable in the appropriate place.
  1286.  
  1287.  
  1288.  
  1289.  
  1290.                                                                        PPPPaaaaggggeeee 22220000
  1291.  
  1292.  
  1293.  
  1294.  
  1295.  
  1296.  
  1297. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1298.  
  1299.  
  1300.  
  1301.      The process of creating a library or archive can be a painful one, what
  1302.      with all the members having to be kept outside the archive as well as
  1303.      inside it in order to keep them from being recreated.  ppppmmmmaaaakkkkeeee has been set
  1304.      up, however, to allow you to reference files that are in an archive in a
  1305.      relatively painless manner.  The specification of an archive member is
  1306.      written as:
  1307.         _a_r_c_h_i_v_e(_m_e_m_b_e_r [_m_e_m_b_e_r...])
  1308.      Both the open and close parentheses are required and there may be any
  1309.      number of members between them (except 0, that is). Members may also
  1310.      include wildcards characters.  When such a source is examined, it is the
  1311.      modification time of the member, as recorded in the archive, that is used
  1312.      to determine its datedness.
  1313.  
  1314.      If an archive member has no commands associated with it, ppppmmmmaaaakkkkeeee goes
  1315.      through a special process to find commands for it.  First, implicit
  1316.      sources are sought using the ``member'' portion of the specification. So
  1317.      if you have something like ``libmalloc.a(malloc.o)'' for a target, ppppmmmmaaaakkkkeeee
  1318.      attempts to find sources for the file ``malloc.o,'' even if it doesn't
  1319.      exist. If such sources exist, ppppmmmmaaaakkkkeeee then looks for a transformation rule
  1320.      from the member's suffix to the archive's (in this case from .o -> .a)
  1321.      and tacks those commands on as well.
  1322.  
  1323.      To make these transformations easier to write, three local variables are
  1324.      defined for the target:
  1325.  
  1326.           .ARCHIVE  (%)       The path to the archive file.
  1327.  
  1328.           .MEMBER  (!)        The actual member name (literally the part in
  1329.                               parentheses).
  1330.  
  1331.           .TARGET  (@)        The path to the file which will be archived, if
  1332.                               it is only a source, or the same as the ....MMMMEEEEMMMMBBBBEEEERRRR
  1333.                               variable if it is also a target.
  1334.  
  1335.      Using the transformations already in the system makefile, a makefile for
  1336.      a library might look something like this:
  1337.         OBJS = setup.o doit.o transfer.o shutdown.o
  1338.         .o.a :
  1339.              ...
  1340.              rm -f $(.MEMBER)
  1341.  
  1342.         lib.a : lib.a($(OBJS))
  1343.              ar  cru  $(.TARGET)  $(.OODATE)
  1344.      Note that the following .o -> .a transformation is bad:
  1345.         .o.a :
  1346.              ar  r  $(.ARCHIVE)  $(.TARGET)
  1347.              ...
  1348.              rm -f  $(.TARGET)
  1349.  
  1350.  
  1351.                                                                        PPPPaaaaggggeeee 22221111
  1352.  
  1353.  
  1354.  
  1355.  
  1356.  
  1357.  
  1358. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1359.  
  1360.  
  1361.  
  1362.      The reason is simple: you should not execute ``ar'' on the same archive
  1363.      several times at once. Also, it is much slower than archiving all the .o
  1364.      files at the end.
  1365.  
  1366. OOOOUUUUTTTTPPPPUUUUTTTT
  1367.      When creating targets in parallel, several shells are executing at once,
  1368.      each wanting to write its output to the screen.  This output must be
  1369.      captured by ppppmmmmaaaakkkkeeee in some way in order to prevent the screen from being
  1370.      filled with garbage even more indecipherable than one can already get
  1371.      from these programs.  ppppmmmmaaaakkkkeeee has two ways of doing this, one of which
  1372.      provides for much cleaner output and a clear delineation between the
  1373.      output of different jobs, the other of which provides a more immediate
  1374.      response so one can tell what is really happening.  The former is done by
  1375.      notifying the user when the creation of a given target starts, capturing
  1376.      the output, and transferring it to the screen when the job finishes,
  1377.      preceded by an indication as to which job produced the output.  The
  1378.      latter is done by catching the output of the shell (and its children) and
  1379.      buffering it until an entire line is received, then printing that line
  1380.      preceded by the name of the job from which the line came.  The name of
  1381.      the job is just the target which is being created by it.  Since this
  1382.      second method is preferred, it is the one used by default.  The first
  1383.      method will be used if the ----PPPP flag is given to ppppmmmmaaaakkkkeeee.
  1384.  
  1385. PPPPAAAARRRRAAAALLLLLLLLEEEELLLLIIIISSSSMMMM
  1386.      ppppmmmmaaaakkkkeeee and _ssss_mmmm_aaaa_kkkk_eeee attempt to create several targets at once.  The degree of
  1387.      useful concurrency depends on the targets, as well as the number of
  1388.      processors on the machine.  On IRIX, the default concurrency value for
  1389.      single-processor systems is 2.  On multi-processor systems that have more
  1390.      than 1 unrestricted processor, the value is 4 (see _m_p_a_d_m_i_n(1) to change
  1391.      the number of unrestricted processors).  To change the default
  1392.      concurrency, use the ----JJJJ flag.  This flag can be set on the command line,
  1393.      inside a makefile with the ....MMMMAAAAKKKKEEEEFFFFLLLLAAAAGGGGSSSS target or with the PPPPMMMMAAAAKKKKEEEE
  1394.      environment variable.
  1395.  
  1396. DDDDEEEEBBBBUUUUGGGGGGGGIIIINNNNGGGG
  1397.      To debug makefiles, use the ----dddd _w_h_a_t option to print various information
  1398.      about ppppmmmmaaaakkkkeeee's internal processing.  The _w_h_a_t argument is a string of
  1399.      single characters that tell ppppmmmmaaaakkkkeeee what aspects you are interested in. The
  1400.      characters and the information they produce are as follows:
  1401.  
  1402.           a    Archive searching and caching.
  1403.  
  1404.           c    Conditional evaluation.
  1405.  
  1406.           d    The searching and caching of directories.
  1407.  
  1408.           j    Various snippets of information related to the running of the
  1409.                multiple shells.
  1410.  
  1411.           m    The making of each target: what target is being examined; when
  1412.                it was last modified; whether it is out-of-date; etc.
  1413.  
  1414.  
  1415.  
  1416.  
  1417.                                                                        PPPPaaaaggggeeee 22222222
  1418.  
  1419.  
  1420.  
  1421.  
  1422.  
  1423.  
  1424. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1425.  
  1426.  
  1427.  
  1428.           s    The application of suffix-transformation rules.
  1429.  
  1430.           t    The maintenance of the list of targets.
  1431.  
  1432.           v    Variable assignment.
  1433.  
  1434.           A or *
  1435.                Print all information.
  1436.  
  1437.      Of these all, the mmmm and ssss letters will be most useful to you.  If the ----dddd
  1438.      is the final argument or the argument from which it would get these key
  1439.      letters begins with a ----, all of these debugging flags will be set,
  1440.      resulting in massive amounts of output.
  1441.  
  1442. CCCCOOOOMMMMPPPPAAAATTTTIIIIBBBBIIIILLLLIIIITTTTYYYY
  1443.      Invoking ppppmmmmaaaakkkkeeee as ssssmmmmaaaakkkkeeee or using the -_v option turns on numerous
  1444.      compatibility options.  However there are still a few areas where ppppmmmmaaaakkkkeeee's
  1445.      behavior differs from classic System V mmmmaaaakkkkeeee.
  1446.  
  1447.      The -_d option in mmmmaaaakkkkeeee doesn't take any sub-options, whereas in ppppmmmmaaaakkkkeeee it
  1448.      does.
  1449.  
  1450.      In ppppmmmmaaaakkkkeeee the standard output and standard error streams for all executed
  1451.      rules are merged together.  Unlike mmmmaaaakkkkeeee it is impossible to redirect the
  1452.      standard error of a rule to a location other than the standard output of
  1453.      ppppmmmmaaaakkkkeeee.
  1454.  
  1455.      The set of default suffixes defined is not completely the same between
  1456.      ppppmmmmaaaakkkkeeee and mmmmaaaakkkkeeee.  In particular the suffixes ._a and ._b are defined in
  1457.      ssssyyyysssstttteeeemmmm....mmmmkkkk for ppppmmmmaaaakkkkeeee while in mmmmaaaakkkkeeee they are not.  This means that single
  1458.      (or NULL) suffix rules will not be applied to ._a files in ppppmmmmaaaakkkkeeee whereas
  1459.      they will (potentially) be applied in mmmmaaaakkkkeeee.  To make ppppmmmmaaaakkkkeeee the same as
  1460.      mmmmaaaakkkkeeee one would have to undefine all the pre-defined suffixes, and add
  1461.      back just those that were in common with mmmmaaaakkkkeeee.
  1462.  
  1463.      The ----nnnn option functions quite differently between ppppmmmmaaaakkkkeeee and mmmmaaaakkkkeeee.  mmmmaaaakkkkeeee
  1464.      will scan each shell command looking for potential re-invocations of
  1465.      itself, and if it finds one, will assume that it is a recursive make and
  1466.      execute the line.  ppppmmmmaaaakkkkeeee does no such scanning of the shell commands and
  1467.      will only execute a command in ----nnnn mode if the target is specified as a
  1468.      recursive target using the ....RRRREEEECCCCUUUURRRRSSSSIIIIVVVVEEEE attribute.
  1469.  
  1470.      The treatment of the _SSSS_HHHH_EEEE_LLLL_LLLL environment variable differs - _pppp_mmmm_aaaa_kkkk_eeee is in
  1471.      conformance with POSIX 1003.2.
  1472.  
  1473.      The compatibility modes of ppppmmmmaaaakkkkeeee attempt to emulate a 'least common
  1474.      denominator' version of mmmmaaaakkkkeeee as might be found in early _B_S_D releases or
  1475.      System V Release 3.  It makes no attempt to emulate the more modern
  1476.      features found in later System V and BSD releases.
  1477.  
  1478.  
  1479.  
  1480.  
  1481.  
  1482.  
  1483.                                                                        PPPPaaaaggggeeee 22223333
  1484.  
  1485.  
  1486.  
  1487.  
  1488.  
  1489.  
  1490. PPPPMMMMAAAAKKKKEEEE((((1111))))                                                              PPPPMMMMAAAAKKKKEEEE((((1111))))
  1491.  
  1492.  
  1493.  
  1494. FFFFIIIILLLLEEEESSSS
  1495.      Makefile or makefile           default input file
  1496.  
  1497.      $(TOOLROOT)/usr/include/make/system.mk  System makefile (the built-in
  1498.                                              rules)
  1499.  
  1500.      /usr/include/make/system.mk    Alternate system makefile (the built-in
  1501.                                     rules)
  1502.  
  1503.      /usr/include/make/makelib.mk   .USE target for making archives
  1504.  
  1505.      /usr/include/make/makelint.mk  .USE target for making lint libraries
  1506.  
  1507. EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT
  1508.      PPPPMMMMAAAAKKKKEEEE   Flags _pppp_mmmm_aaaa_kkkk_eeee and _ssss_mmmm_aaaa_kkkk_eeee should always use when invoked.
  1509.      _SSSS_HHHH_EEEE_LLLL_LLLL   Not used to set shell interpretor for commands.
  1510.  
  1511. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  1512.      mmmmaaaakkkkeeee(1) for a more complete explanation of the lower-case flags to ppppmmmmaaaakkkkeeee.
  1513.  
  1514.      There are numerous books on _mmmm_aaaa_kkkk_eeee usage.  These explain many of the
  1515.      features described here though most versions of _mmmm_aaaa_kkkk_eeee are not as feature
  1516.      rich as _pppp_mmmm_aaaa_kkkk_eeee.  One such book is:_M_a_n_a_g_i_n_g _P_r_o_j_e_c_t_s _w_i_t_h _M_a_k_e, _2_n_d _e_d.;
  1517.      authored by _A_n_d_r_e_w _O_r_a_m and _S_t_e_v_e _T_a_l_b_o_t_t, from O'Reilly & Associates.
  1518.  
  1519.  
  1520.  
  1521.  
  1522.  
  1523.  
  1524.  
  1525.  
  1526.  
  1527.  
  1528.  
  1529.  
  1530.  
  1531.  
  1532.  
  1533.  
  1534.  
  1535.  
  1536.  
  1537.  
  1538.  
  1539.  
  1540.  
  1541.  
  1542.  
  1543.  
  1544.  
  1545.  
  1546.  
  1547.  
  1548.  
  1549.                                                                        PPPPaaaaggggeeee 22224444
  1550.  
  1551.  
  1552.  
  1553.